package com.shm.leetcode;
/**
 * @author: shm
 * @dateTime: 2020/11/21 9:51
 * @description: 148. 排序链表
 * 给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。
 *
 * 进阶：
 *
 * 你可以在 O(n log n) 时间复杂度和常数级空间复杂度下，对链表进行排序吗？
 *
 *
 * 示例 1：
 *
 *
 * 输入：head = [4,2,1,3]
 * 输出：[1,2,3,4]
 * 示例 2：
 *
 *
 * 输入：head = [-1,5,3,4,0]
 * 输出：[-1,0,3,4,5]
 * 示例 3：
 *
 * 输入：head = []
 * 输出：[]
 *
 *
 * 提示：
 *
 * 链表中节点的数目在范围 [0, 5 * 104] 内
 * -105 <= Node.val <= 105
 */
public class SortList {
    public ListNode sortList_1(ListNode head) {
        if(head==null){
            return head;
        }
        ListNode dummyHead = new ListNode(-1);
        dummyHead.next = head;
        ListNode sorted = head;
        ListNode curr = head.next;
        while (curr!=null){
            if (sorted.val<=curr.val){
                sorted=sorted.next;
            }else {
                ListNode node = dummyHead;
                while (node.next.val<curr.val){
                    node = node.next;
                }
                sorted.next = curr.next;
                curr.next = node.next;
                node.next = curr;
            }
            curr = sorted.next;
        }
        return dummyHead.next;
    }

    /***
     * 前言
     * 「147. 对链表进行插入排序」要求使用插入排序的方法对链表进行排序，插入排序的时间复杂度是 O(n^2)O(n
     * 2
     *  )，其中 nn 是链表的长度。这道题考虑时间复杂度更低的排序算法。题目的进阶问题要求达到 O(n \log n)O(nlogn) 的时间复杂度和 O(1)O(1) 的空间复杂度，时间复杂度是 O(n \log n)O(nlogn) 的排序算法包括归并排序、堆排序和快速排序（快速排序的最差时间复杂度是 O(n^2)O(n
     * 2
     *  )），其中最适合链表的排序算法是归并排序。
     *
     * 归并排序基于分治算法。最容易想到的实现方式是自顶向下的递归实现，考虑到递归调用的栈空间，自顶向下归并排序的空间复杂度是 O(\log n)O(logn)。如果要达到 O(1)O(1) 的空间复杂度，则需要使用自底向上的实现方式。
     *
     * 方法一：自顶向下归并排序
     * 对链表自顶向下归并排序的过程如下。
     *
     * 找到链表的中点，以中点为分界，将链表拆分成两个子链表。寻找链表的中点可以使用快慢指针的做法，快指针每次移动 22 步，慢指针每次移动 11 步，当快指针到达链表末尾时，慢指针指向的链表节点即为链表的中点。
     *
     * 对两个子链表分别排序。
     *
     * 将两个排序后的子链表合并，得到完整的排序后的链表。可以使用「21. 合并两个有序链表」的做法，将两个有序的子链表进行合并。
     *
     * 上述过程可以通过递归实现。递归的终止条件是链表的节点个数小于或等于 11，即当链表为空或者链表只包含 11 个节点时，不需要对链表进行拆分和排序。
     *
     * 复杂度分析
     *
     * 时间复杂度：O(n \log n)O(nlogn)，其中 nn 是链表的长度。
     * 空间复杂度：O(\log n)O(logn)，其中 nn 是链表的长度。空间复杂度主要取决于递归调用的栈空间。
     *
     * 作者：LeetCode-Solution
     * 链接：https://leetcode-cn.com/problems/sort-list/solution/pai-xu-lian-biao-by-leetcode-solution/
     * @param head
     * @return
     */
    public ListNode sortList(ListNode head) {
        return sortList(head,null);
    }

    public ListNode sortList(ListNode head,ListNode tail){
        if (head==null){
            return head;
        }
        if (head.next==tail){
            head.next=null;//重点
            return head;
        }
        ListNode slow = head,fast= head;

        while (fast!=tail){//易错
            slow=slow.next;
            fast = fast.next;
            if (fast!=tail){//易错
                fast=fast.next;
            }
        }
        ListNode mid = slow;
        ListNode list1 = sortList(head,mid);
        ListNode list2 = sortList(mid,tail);
        return merge(list1,list2);
    }

    public ListNode merge(ListNode head1,ListNode head2){
        ListNode dummyHead = new ListNode(0);
        ListNode tmp = dummyHead,tmp1 = head1,tmp2 = head2;
        while (tmp1!=null&&tmp2!=null) {
            if (tmp1.val <= tmp2.val) {
                tmp.next = tmp1;
                tmp1 = tmp1.next;
            } else {
                tmp.next = tmp2;
                tmp2 = tmp2.next;
            }
            tmp = tmp.next;
        }
        if (tmp1!=null){
            tmp.next = tmp1;
        }
        if (tmp2!=null){
            tmp.next = tmp2;
        }
        return dummyHead.next;
    }

    /***
     * 方法二：自底向上归并排序
     * 使用自底向上的方法实现归并排序，则可以达到 O(1)O(1) 的空间复杂度。
     *
     * 首先求得链表的长度 \textit{length}length，然后将链表拆分成子链表进行合并。
     *
     * 具体做法如下。
     *
     * 用 \textit{subLength}subLength 表示每次需要排序的子链表的长度，初始时 \textit{subLength}=1subLength=1。
     *
     * 每次将链表拆分成若干个长度为 \textit{subLength}subLength 的子链表（最后一个子链表的长度可以小于 \textit{subLength}subLength），按照每两个子链表一组进行合并，合并后即可得到若干个长度为 \textit{subLength} \times 2subLength×2 的有序子链表（最后一个子链表的长度可以小于 \textit{subLength} \times 2subLength×2）。合并两个子链表仍然使用「21. 合并两个有序链表」的做法。
     *
     * 将 \textit{subLength}subLength 的值加倍，重复第 2 步，对更长的有序子链表进行合并操作，直到有序子链表的长度大于或等于 \textit{length}length，整个链表排序完毕。
     *
     * 如何保证每次合并之后得到的子链表都是有序的呢？可以通过数学归纳法证明。
     *
     * 初始时 \textit{subLength}=1subLength=1，每个长度为 11 的子链表都是有序的。
     *
     * 如果每个长度为 \textit{subLength}subLength 的子链表已经有序，合并两个长度为 \textit{subLength}subLength 的有序子链表，得到长度为 \textit{subLength} \times 2subLength×2 的子链表，一定也是有序的。
     *
     * 当最后一个子链表的长度小于 \textit{subLength}subLength 时，该子链表也是有序的，合并两个有序子链表之后得到的子链表一定也是有序的。
     *
     * 因此可以保证最后得到的链表是有序的。
     * 复杂度分析
     *
     * 时间复杂度：O(n \log n)O(nlogn)，其中 nn 是链表的长度。
     * 空间复杂度：O(1)O(1)。
     *
     * 作者：LeetCode-Solution
     * 链接：https://leetcode-cn.com/problems/sort-list/solution/pai-xu-lian-biao-by-leetcode-solution/
     * @param head
     * @return
     */
    public ListNode sortList_2(ListNode head) {
        if (head==null){
            return head;
        }
        int length = 0;
        ListNode node = head;
        while (node!=null){
            length++;
            node = node.next;
        }
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head;
        for (int subLength = 1; subLength < length; subLength<<=1) {
            ListNode pre = dummyHead,curr=dummyHead.next;
            while (curr!=null){
                ListNode head1 = curr;
                for (int i = 1; i < subLength&&curr.next!=null; i++) {
                    curr=curr.next;
                }
                ListNode head2 = curr.next;
                curr.next = null;
                curr = head2;
                for (int i = 1; i < subLength&&curr!=null&&curr.next!=null; i++) {
                    curr=curr.next;
                }
                ListNode next = null;
                if (curr!=null){
                    next = curr.next;
                    curr.next = null;
                }
                ListNode merge = merge(head1,head2);
                pre.next = merge;
                while (pre.next!=null){
                    pre = pre.next;
                }
                curr = next;
            }
        }
        return dummyHead.next;
    }
}
